import cv2
import matplotlib.pyplot as plt

# Load the left and right images
left_image = cv2.imread('./images/aloeL.jpg', 0)
right_image = cv2.imread('./images/aloeR.jpg', 0)

# Create a StereoBM object
stereo = cv2.StereoBM_create(numDisparities=16, blockSize=15)  # You can adjust the parameters as needed

# Compute the disparity map
disparity_map = stereo.compute(left_image, right_image)

# Normalize the disparity map for visualization
disparity_map = cv2.normalize(disparity_map, disparity_map, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)

# Display the disparity map using Matplotlib
plt.figure(figsize=(10, 7))
plt.imshow(disparity_map, cmap='jet')
plt.colorbar()
plt.title('Disparity Map')
plt.axis('off')
plt.show()

# Create a list of parameter values to test
num_disparities_values = [16, 32, 64]  # Vary the numDisparities parameter
block_size_values = [15, 21, 31]      # Vary the blockSize parameter

# Create subplots for displaying the disparity maps
fig, axes = plt.subplots(len(num_disparities_values), len(block_size_values), figsize=(12, 8))

for i, num_disparities in enumerate(num_disparities_values):
    for j, block_size in enumerate(block_size_values):
        # Create a StereoBM object with the current parameters
        stereo = cv2.StereoBM_create(numDisparities=num_disparities, blockSize=block_size)
        
        # Compute the disparity map
        disparity_map = stereo.compute(left_image, right_image)
        
        # Normalize the disparity map for visualization
        disparity_map = cv2.normalize(disparity_map, disparity_map, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)
        
        # Display the disparity map in the subplot
        axes[i, j].imshow(disparity_map, cmap='jet')
        axes[i, j].set_title(f'numDisparities={num_disparities}, blockSize={block_size}')
        axes[i, j].axis('off')

plt.tight_layout()
plt.show()

from glob import glob

img_names = glob('./images/left??.jpg')

# a)
# Function to find the feature points using cv2.findChessboardCorners(...)
# If the function finds the corners, return them, otherwise return None  
def findCorners(filename, pattern_size):
    img = cv2.imread(filename, 0)
    # Find the corners on the chessboard
    found, corners = cv2.findChessboardCorners(img, pattern_size)

    if not found: return None
    
    return corners.reshape(-1, 2)

# b)
# Function to calibrate the camera.
# Return the camera matrix and the distortion coeffiecients (radial & tangential)
def calibrateTheCamera(obj_points, img_points, img_shape):
    # Calibrate the camera and return the camera matrix and distortion coefficients
    ret, camera_matrix, dist_coeffs, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, img_shape, None, None)
    return camera_matrix, dist_coeffs

# c)
# Function that undistort the images using cv2.getOptimalNewCameraMatrix(...) and cv2.undistort(...)
# Plot the new undistorted images.
def undistortImage(filename, camera_matrix, dist_coefs):
    
    img = cv2.imread(filename,0)
    h, w = img.shape[:2]

    # Returns the new camera intrinsic matrix based on the camera matrix and the distortion coefficients
    new_camera_matrix, _ = cv2.getOptimalNewCameraMatrix(camera_matrix, dist_coefs, (w, h), 1, (w, h))

    # Transforms an image to compensate for lens distortion using the camera matrix,
    # the distortion coefficients, and the camera matrix of the distorted image.
    undistorted_img = cv2.undistort(img, camera_matrix, dist_coefs, None, new_camera_matrix)

    plt.figure(figsize=(10, 10))
    plt.imshow(undistorted_img, cmap='gray')
    plt.title('Undistorted Image')
    plt.axis('off')
    plt.show()

from glob import glob

obj_points = []
img_points = []
img_names = glob('./images/left*.jpg')


# From the documentation of cv2.findChessboardCorners:
# patternSize – Number of inner corners per a chessboard row and column
#( patternSize = cvSize(points_per_row,points_per_colum) = cvSize(columns,rows) ).
pattern_size = (9,6)

# Defining the world coordinates for 3D points
pattern_points = np.zeros((np.prod(pattern_size), 3), np.float32)
pattern_points[:, :2] = np.indices(pattern_size).T.reshape(-1, 2)
pattern_points *= 1

#### a)
# Find feature points with checkerboard images.
chessboards = [findCorners(filename, pattern_size) for filename in img_names]
for corners in [chessboard for chessboard in chessboards if chessboard is not None]:
    img_points.append(corners)
    obj_points.append(pattern_points)

#### b)
# Get the camera matrix and the distortion coeffiecients (radial & tangential).
img_shape = cv2.imread(img_names[0], cv2.IMREAD_GRAYSCALE).shape[:2]
camera_matrix, dist_coefs = calibrateTheCamera(obj_points, img_points, img_shape)

#### c) 
# Undistort the images and plot them.
for filename in img_names:
    undistortImage(filename, camera_matrix, dist_coefs)

ELE510 Image Processing with robot vision: LAB, Exercise 7, Stereo Vision and Camera Calibration.¶

Problem 1 (Correspondence problem)¶

Problem 2 (Block Matching)¶

Problem 3 (Camera calibration)¶

Delivery (dead line) on CANVAS: 21.10.2022 at 23:59¶

Contact¶

Course teacher¶

Teaching assistant¶

References¶